home *** CD-ROM | disk | FTP | other *** search
/ PCGUIA 127 / PC Guia 127.iso / Software / Produtividade / OpenOffice.org 2.0.1 / openofficeorg4.cab / test_itertools.py < prev    next >
Text File  |  2005-11-19  |  23KB  |  650 lines
  1. import unittest
  2. from test import test_support
  3. from itertools import *
  4. import sys
  5. import operator
  6.  
  7. def onearg(x):
  8.     'Test function of one argument'
  9.     return 2*x
  10.  
  11. def errfunc(*args):
  12.     'Test function that raises an error'
  13.     raise ValueError
  14.  
  15. def gen3():
  16.     'Non-restartable source sequence'
  17.     for i in (0, 1, 2):
  18.         yield i
  19.  
  20. def isEven(x):
  21.     'Test predicate'
  22.     return x%2==0
  23.  
  24. def isOdd(x):
  25.     'Test predicate'
  26.     return x%2==1
  27.  
  28. class StopNow:
  29.     'Class emulating an empty iterable.'
  30.     def __iter__(self):
  31.         return self
  32.     def next(self):
  33.         raise StopIteration
  34.  
  35. def take(n, seq):
  36.     'Convenience function for partially consuming a long of infinite iterable'
  37.     return list(islice(seq, n))
  38.  
  39. class TestBasicOps(unittest.TestCase):
  40.     def test_chain(self):
  41.         self.assertEqual(list(chain('abc', 'def')), list('abcdef'))
  42.         self.assertEqual(list(chain('abc')), list('abc'))
  43.         self.assertEqual(list(chain('')), [])
  44.         self.assertEqual(take(4, chain('abc', 'def')), list('abcd'))
  45.         self.assertRaises(TypeError, chain, 2, 3)
  46.  
  47.     def test_count(self):
  48.         self.assertEqual(zip('abc',count()), [('a', 0), ('b', 1), ('c', 2)])
  49.         self.assertEqual(zip('abc',count(3)), [('a', 3), ('b', 4), ('c', 5)])
  50.         self.assertEqual(take(2, zip('abc',count(3))), [('a', 3), ('b', 4)])
  51.         self.assertRaises(TypeError, count, 2, 3)
  52.         self.assertRaises(TypeError, count, 'a')
  53.         c = count(sys.maxint-2)   # verify that rollover doesn't crash
  54.         c.next(); c.next(); c.next(); c.next(); c.next()
  55.  
  56.     def test_cycle(self):
  57.         self.assertEqual(take(10, cycle('abc')), list('abcabcabca'))
  58.         self.assertEqual(list(cycle('')), [])
  59.         self.assertRaises(TypeError, cycle)
  60.         self.assertRaises(TypeError, cycle, 5)
  61.         self.assertEqual(list(islice(cycle(gen3()),10)), [0,1,2,0,1,2,0,1,2,0])
  62.  
  63.     def test_ifilter(self):
  64.         self.assertEqual(list(ifilter(isEven, range(6))), [0,2,4])
  65.         self.assertEqual(list(ifilter(None, [0,1,0,2,0])), [1,2])
  66.         self.assertEqual(take(4, ifilter(isEven, count())), [0,2,4,6])
  67.         self.assertRaises(TypeError, ifilter)
  68.         self.assertRaises(TypeError, ifilter, lambda x:x)
  69.         self.assertRaises(TypeError, ifilter, lambda x:x, range(6), 7)
  70.         self.assertRaises(TypeError, ifilter, isEven, 3)
  71.         self.assertRaises(TypeError, ifilter(range(6), range(6)).next)
  72.  
  73.     def test_ifilterfalse(self):
  74.         self.assertEqual(list(ifilterfalse(isEven, range(6))), [1,3,5])
  75.         self.assertEqual(list(ifilterfalse(None, [0,1,0,2,0])), [0,0,0])
  76.         self.assertEqual(take(4, ifilterfalse(isEven, count())), [1,3,5,7])
  77.         self.assertRaises(TypeError, ifilterfalse)
  78.         self.assertRaises(TypeError, ifilterfalse, lambda x:x)
  79.         self.assertRaises(TypeError, ifilterfalse, lambda x:x, range(6), 7)
  80.         self.assertRaises(TypeError, ifilterfalse, isEven, 3)
  81.         self.assertRaises(TypeError, ifilterfalse(range(6), range(6)).next)
  82.  
  83.     def test_izip(self):
  84.         ans = [(x,y) for x, y in izip('abc',count())]
  85.         self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
  86.         self.assertEqual(list(izip('abc', range(6))), zip('abc', range(6)))
  87.         self.assertEqual(list(izip('abcdef', range(3))), zip('abcdef', range(3)))
  88.         self.assertEqual(take(3,izip('abcdef', count())), zip('abcdef', range(3)))
  89.         self.assertEqual(list(izip('abcdef')), zip('abcdef'))
  90.         self.assertEqual(list(izip()), [])
  91.         self.assertRaises(TypeError, izip, 3)
  92.         self.assertRaises(TypeError, izip, range(3), 3)
  93.         # Check tuple re-use (implementation detail)
  94.         self.assertEqual([tuple(list(pair)) for pair in izip('abc', 'def')],
  95.                          zip('abc', 'def'))
  96.         self.assertEqual([pair for pair in izip('abc', 'def')],
  97.                          zip('abc', 'def'))
  98.         ids = map(id, izip('abc', 'def'))
  99.         self.assertEqual(min(ids), max(ids))
  100.         ids = map(id, list(izip('abc', 'def')))
  101.         self.assertEqual(len(dict.fromkeys(ids)), len(ids))
  102.  
  103.     def test_repeat(self):
  104.         self.assertEqual(zip(xrange(3),repeat('a')),
  105.                          [(0, 'a'), (1, 'a'), (2, 'a')])
  106.         self.assertEqual(list(repeat('a', 3)), ['a', 'a', 'a'])
  107.         self.assertEqual(take(3, repeat('a')), ['a', 'a', 'a'])
  108.         self.assertEqual(list(repeat('a', 0)), [])
  109.         self.assertEqual(list(repeat('a', -3)), [])
  110.         self.assertRaises(TypeError, repeat)
  111.         self.assertRaises(TypeError, repeat, None, 3, 4)
  112.         self.assertRaises(TypeError, repeat, None, 'a')
  113.  
  114.     def test_imap(self):
  115.         self.assertEqual(list(imap(operator.pow, range(3), range(1,7))),
  116.                          [0**1, 1**2, 2**3])
  117.         self.assertEqual(list(imap(None, 'abc', range(5))),
  118.                          [('a',0),('b',1),('c',2)])
  119.         self.assertEqual(list(imap(None, 'abc', count())),
  120.                          [('a',0),('b',1),('c',2)])
  121.         self.assertEqual(take(2,imap(None, 'abc', count())),
  122.                          [('a',0),('b',1)])
  123.         self.assertEqual(list(imap(operator.pow, [])), [])
  124.         self.assertRaises(TypeError, imap)
  125.         self.assertRaises(TypeError, imap, operator.neg)
  126.         self.assertRaises(TypeError, imap(10, range(5)).next)
  127.         self.assertRaises(ValueError, imap(errfunc, [4], [5]).next)
  128.         self.assertRaises(TypeError, imap(onearg, [4], [5]).next)
  129.  
  130.     def test_starmap(self):
  131.         self.assertEqual(list(starmap(operator.pow, zip(range(3), range(1,7)))),
  132.                          [0**1, 1**2, 2**3])
  133.         self.assertEqual(take(3, starmap(operator.pow, izip(count(), count(1)))),
  134.                          [0**1, 1**2, 2**3])
  135.         self.assertEqual(list(starmap(operator.pow, [])), [])
  136.         self.assertRaises(TypeError, list, starmap(operator.pow, [[4,5]]))
  137.         self.assertRaises(TypeError, starmap)
  138.         self.assertRaises(TypeError, starmap, operator.pow, [(4,5)], 'extra')
  139.         self.assertRaises(TypeError, starmap(10, [(4,5)]).next)
  140.         self.assertRaises(ValueError, starmap(errfunc, [(4,5)]).next)
  141.         self.assertRaises(TypeError, starmap(onearg, [(4,5)]).next)
  142.  
  143.     def test_islice(self):
  144.         for args in [          # islice(args) should agree with range(args)
  145.                 (10, 20, 3),
  146.                 (10, 3, 20),
  147.                 (10, 20),
  148.                 (10, 3),
  149.                 (20,)
  150.                 ]:
  151.             self.assertEqual(list(islice(xrange(100), *args)), range(*args))
  152.  
  153.         for args, tgtargs in [  # Stop when seqn is exhausted
  154.                 ((10, 110, 3), ((10, 100, 3))),
  155.                 ((10, 110), ((10, 100))),
  156.                 ((110,), (100,))
  157.                 ]:
  158.             self.assertEqual(list(islice(xrange(100), *args)), range(*tgtargs))
  159.  
  160.         # Test stop=None
  161.         self.assertEqual(list(islice(xrange(10), None)), range(10))
  162.         self.assertEqual(list(islice(xrange(10), 2, None)), range(2, 10))
  163.         self.assertEqual(list(islice(xrange(10), 1, None, 2)), range(1, 10, 2))
  164.  
  165.         # Test invalid arguments
  166.         self.assertRaises(TypeError, islice, xrange(10))
  167.         self.assertRaises(TypeError, islice, xrange(10), 1, 2, 3, 4)
  168.         self.assertRaises(ValueError, islice, xrange(10), -5, 10, 1)
  169.         self.assertRaises(ValueError, islice, xrange(10), 1, -5, -1)
  170.         self.assertRaises(ValueError, islice, xrange(10), 1, 10, -1)
  171.         self.assertRaises(ValueError, islice, xrange(10), 1, 10, 0)
  172.         self.assertRaises(ValueError, islice, xrange(10), 'a')
  173.         self.assertRaises(ValueError, islice, xrange(10), 'a', 1)
  174.         self.assertRaises(ValueError, islice, xrange(10), 1, 'a')
  175.         self.assertRaises(ValueError, islice, xrange(10), 'a', 1, 1)
  176.         self.assertRaises(ValueError, islice, xrange(10), 1, 'a', 1)
  177.         self.assertEqual(len(list(islice(count(), 1, 10, sys.maxint))), 1)
  178.  
  179.     def test_takewhile(self):
  180.         data = [1, 3, 5, 20, 2, 4, 6, 8]
  181.         underten = lambda x: x<10
  182.         self.assertEqual(list(takewhile(underten, data)), [1, 3, 5])
  183.         self.assertEqual(list(takewhile(underten, [])), [])
  184.         self.assertRaises(TypeError, takewhile)
  185.         self.assertRaises(TypeError, takewhile, operator.pow)
  186.         self.assertRaises(TypeError, takewhile, operator.pow, [(4,5)], 'extra')
  187.         self.assertRaises(TypeError, takewhile(10, [(4,5)]).next)
  188.         self.assertRaises(ValueError, takewhile(errfunc, [(4,5)]).next)
  189.  
  190.     def test_dropwhile(self):
  191.         data = [1, 3, 5, 20, 2, 4, 6, 8]
  192.         underten = lambda x: x<10
  193.         self.assertEqual(list(dropwhile(underten, data)), [20, 2, 4, 6, 8])
  194.         self.assertEqual(list(dropwhile(underten, [])), [])
  195.         self.assertRaises(TypeError, dropwhile)
  196.         self.assertRaises(TypeError, dropwhile, operator.pow)
  197.         self.assertRaises(TypeError, dropwhile, operator.pow, [(4,5)], 'extra')
  198.         self.assertRaises(TypeError, dropwhile(10, [(4,5)]).next)
  199.         self.assertRaises(ValueError, dropwhile(errfunc, [(4,5)]).next)
  200.  
  201.     def test_StopIteration(self):
  202.         self.assertRaises(StopIteration, izip().next)
  203.  
  204.         for f in (chain, cycle, izip):
  205.             self.assertRaises(StopIteration, f([]).next)
  206.             self.assertRaises(StopIteration, f(StopNow()).next)
  207.  
  208.         self.assertRaises(StopIteration, islice([], None).next)
  209.         self.assertRaises(StopIteration, islice(StopNow(), None).next)
  210.  
  211.         self.assertRaises(StopIteration, repeat(None, 0).next)
  212.  
  213.         for f in (ifilter, ifilterfalse, imap, takewhile, dropwhile, starmap):
  214.             self.assertRaises(StopIteration, f(lambda x:x, []).next)
  215.             self.assertRaises(StopIteration, f(lambda x:x, StopNow()).next)
  216.  
  217. def R(seqn):
  218.     'Regular generator'
  219.     for i in seqn:
  220.         yield i
  221.  
  222. class G:
  223.     'Sequence using __getitem__'
  224.     def __init__(self, seqn):
  225.         self.seqn = seqn
  226.     def __getitem__(self, i):
  227.         return self.seqn[i]
  228.  
  229. class I:
  230.     'Sequence using iterator protocol'
  231.     def __init__(self, seqn):
  232.         self.seqn = seqn
  233.         self.i = 0
  234.     def __iter__(self):
  235.         return self
  236.     def next(self):
  237.         if self.i >= len(self.seqn): raise StopIteration
  238.         v = self.seqn[self.i]
  239.         self.i += 1
  240.         return v
  241.  
  242. class Ig:
  243.     'Sequence using iterator protocol defined with a generator'
  244.     def __init__(self, seqn):
  245.         self.seqn = seqn
  246.         self.i = 0
  247.     def __iter__(self):
  248.         for val in self.seqn:
  249.             yield val
  250.  
  251. class X:
  252.     'Missing __getitem__ and __iter__'
  253.     def __init__(self, seqn):
  254.         self.seqn = seqn
  255.         self.i = 0
  256.     def next(self):
  257.         if self.i >= len(self.seqn): raise StopIteration
  258.         v = self.seqn[self.i]
  259.         self.i += 1
  260.         return v
  261.  
  262. class N:
  263.     'Iterator missing next()'
  264.     def __init__(self, seqn):
  265.         self.seqn = seqn
  266.         self.i = 0
  267.     def __iter__(self):
  268.         return self
  269.  
  270. class E:
  271.     'Test propagation of exceptions'
  272.     def __init__(self, seqn):
  273.         self.seqn = seqn
  274.         self.i = 0
  275.     def __iter__(self):
  276.         return self
  277.     def next(self):
  278.         3/0
  279.  
  280. class S:
  281.     'Test immediate stop'
  282.     def __init__(self, seqn):
  283.         pass
  284.     def __iter__(self):
  285.         return self
  286.     def next(self):
  287.         raise StopIteration
  288.  
  289. def L(seqn):
  290.     'Test multiple tiers of iterators'
  291.     return chain(imap(lambda x:x, R(Ig(G(seqn)))))
  292.  
  293. class TestGC(unittest.TestCase):
  294.  
  295.     def makecycle(self, iterator, container):
  296.         container.append(iterator)
  297.         iterator.next()
  298.         del container, iterator
  299.  
  300.     def test_chain(self):
  301.         a = []
  302.         self.makecycle(chain(a), a)
  303.  
  304.     def test_cycle(self):
  305.         a = []
  306.         self.makecycle(cycle([a]*2), a)
  307.  
  308.     def test_ifilter(self):
  309.         a = []
  310.         self.makecycle(ifilter(lambda x:True, [a]*2), a)
  311.  
  312.     def test_ifilterfalse(self):
  313.         a = []
  314.         self.makecycle(ifilterfalse(lambda x:False, a), a)
  315.  
  316.     def test_izip(self):
  317.         a = []
  318.         self.makecycle(izip([a]*2, [a]*3), a)
  319.  
  320.     def test_imap(self):
  321.         a = []
  322.         self.makecycle(imap(lambda x:x, [a]*2), a)
  323.  
  324.     def test_islice(self):
  325.         a = []
  326.         self.makecycle(islice([a]*2, None), a)
  327.  
  328.     def test_starmap(self):
  329.         a = []
  330.         self.makecycle(starmap(lambda *t: t, [(a,a)]*2), a)
  331.  
  332.  
  333. class TestVariousIteratorArgs(unittest.TestCase):
  334.  
  335.     def test_chain(self):
  336.         for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  337.             for g in (G, I, Ig, S, L, R):
  338.                 self.assertEqual(list(chain(g(s))), list(g(s)))
  339.                 self.assertEqual(list(chain(g(s), g(s))), list(g(s))+list(g(s)))
  340.             self.assertRaises(TypeError, chain, X(s))
  341.             self.assertRaises(TypeError, list, chain(N(s)))
  342.             self.assertRaises(ZeroDivisionError, list, chain(E(s)))
  343.  
  344.     def test_cycle(self):
  345.         for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  346.             for g in (G, I, Ig, S, L, R):
  347.                 tgtlen = len(s) * 3
  348.                 expected = list(g(s))*3
  349.                 actual = list(islice(cycle(g(s)), tgtlen))
  350.                 self.assertEqual(actual, expected)
  351.             self.assertRaises(TypeError, cycle, X(s))
  352.             self.assertRaises(TypeError, list, cycle(N(s)))
  353.             self.assertRaises(ZeroDivisionError, list, cycle(E(s)))
  354.  
  355.     def test_ifilter(self):
  356.         for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
  357.             for g in (G, I, Ig, S, L, R):
  358.                 self.assertEqual(list(ifilter(isEven, g(s))), filter(isEven, g(s)))
  359.             self.assertRaises(TypeError, ifilter, isEven, X(s))
  360.             self.assertRaises(TypeError, list, ifilter(isEven, N(s)))
  361.             self.assertRaises(ZeroDivisionError, list, ifilter(isEven, E(s)))
  362.  
  363.     def test_ifilterfalse(self):
  364.         for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
  365.             for g in (G, I, Ig, S, L, R):
  366.                 self.assertEqual(list(ifilterfalse(isEven, g(s))), filter(isOdd, g(s)))
  367.             self.assertRaises(TypeError, ifilterfalse, isEven, X(s))
  368.             self.assertRaises(TypeError, list, ifilterfalse(isEven, N(s)))
  369.             self.assertRaises(ZeroDivisionError, list, ifilterfalse(isEven, E(s)))
  370.  
  371.     def test_izip(self):
  372.         for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  373.             for g in (G, I, Ig, S, L, R):
  374.                 self.assertEqual(list(izip(g(s))), zip(g(s)))
  375.                 self.assertEqual(list(izip(g(s), g(s))), zip(g(s), g(s)))
  376.             self.assertRaises(TypeError, izip, X(s))
  377.             self.assertRaises(TypeError, list, izip(N(s)))
  378.             self.assertRaises(ZeroDivisionError, list, izip(E(s)))
  379.  
  380.     def test_imap(self):
  381.         for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)):
  382.             for g in (G, I, Ig, S, L, R):
  383.                 self.assertEqual(list(imap(onearg, g(s))), map(onearg, g(s)))
  384.                 self.assertEqual(list(imap(operator.pow, g(s), g(s))), map(operator.pow, g(s), g(s)))
  385.             self.assertRaises(TypeError, imap, onearg, X(s))
  386.             self.assertRaises(TypeError, list, imap(onearg, N(s)))
  387.             self.assertRaises(ZeroDivisionError, list, imap(onearg, E(s)))
  388.  
  389.     def test_islice(self):
  390.         for s in ("12345", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  391.             for g in (G, I, Ig, S, L, R):
  392.                 self.assertEqual(list(islice(g(s),1,None,2)), list(g(s))[1::2])
  393.             self.assertRaises(TypeError, islice, X(s), 10)
  394.             self.assertRaises(TypeError, list, islice(N(s), 10))
  395.             self.assertRaises(ZeroDivisionError, list, islice(E(s), 10))
  396.  
  397.     def test_starmap(self):
  398.         for s in (range(10), range(0), range(100), (7,11), xrange(20,50,5)):
  399.             for g in (G, I, Ig, S, L, R):
  400.                 ss = zip(s, s)
  401.                 self.assertEqual(list(starmap(operator.pow, g(ss))), map(operator.pow, g(s), g(s)))
  402.             self.assertRaises(TypeError, starmap, operator.pow, X(ss))
  403.             self.assertRaises(TypeError, list, starmap(operator.pow, N(ss)))
  404.             self.assertRaises(ZeroDivisionError, list, starmap(operator.pow, E(ss)))
  405.  
  406.     def test_takewhile(self):
  407.         for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
  408.             for g in (G, I, Ig, S, L, R):
  409.                 tgt = []
  410.                 for elem in g(s):
  411.                     if not isEven(elem): break
  412.                     tgt.append(elem)
  413.                 self.assertEqual(list(takewhile(isEven, g(s))), tgt)
  414.             self.assertRaises(TypeError, takewhile, isEven, X(s))
  415.             self.assertRaises(TypeError, list, takewhile(isEven, N(s)))
  416.             self.assertRaises(ZeroDivisionError, list, takewhile(isEven, E(s)))
  417.  
  418.     def test_dropwhile(self):
  419.         for s in (range(10), range(0), range(1000), (7,11), xrange(2000,2200,5)):
  420.             for g in (G, I, Ig, S, L, R):
  421.                 tgt = []
  422.                 for elem in g(s):
  423.                     if not tgt and isOdd(elem): continue
  424.                     tgt.append(elem)
  425.                 self.assertEqual(list(dropwhile(isOdd, g(s))), tgt)
  426.             self.assertRaises(TypeError, dropwhile, isOdd, X(s))
  427.             self.assertRaises(TypeError, list, dropwhile(isOdd, N(s)))
  428.             self.assertRaises(ZeroDivisionError, list, dropwhile(isOdd, E(s)))
  429.  
  430. class RegressionTests(unittest.TestCase):
  431.  
  432.     def test_sf_793826(self):
  433.         # Fix Armin Rigo's successful efforts to wreak havoc
  434.  
  435.         def mutatingtuple(tuple1, f, tuple2):
  436.             # this builds a tuple t which is a copy of tuple1,
  437.             # then calls f(t), then mutates t to be equal to tuple2
  438.             # (needs len(tuple1) == len(tuple2)).
  439.             def g(value, first=[1]):
  440.                 if first:
  441.                     del first[:]
  442.                     f(z.next())
  443.                 return value
  444.             items = list(tuple2)
  445.             items[1:1] = list(tuple1)
  446.             gen = imap(g, items)
  447.             z = izip(*[gen]*len(tuple1))
  448.             z.next()
  449.  
  450.         def f(t):
  451.             global T
  452.             T = t
  453.             first[:] = list(T)
  454.  
  455.         first = []
  456.         mutatingtuple((1,2,3), f, (4,5,6))
  457.         second = list(T)
  458.         self.assertEqual(first, second)
  459.  
  460.  
  461.     def test_sf_950057(self):
  462.         # Make sure that chain() and cycle() catch exceptions immediately
  463.         # rather than when shifting between input sources
  464.  
  465.         def gen1():
  466.             hist.append(0)
  467.             yield 1
  468.             hist.append(1)
  469.             assert False
  470.             hist.append(2)
  471.  
  472.         def gen2(x):
  473.             hist.append(3)
  474.             yield 2
  475.             hist.append(4)
  476.             if x:
  477.                 raise StopIteration
  478.  
  479.         hist = []
  480.         self.assertRaises(AssertionError, list, chain(gen1(), gen2(False)))
  481.         self.assertEqual(hist, [0,1])
  482.  
  483.         hist = []
  484.         self.assertRaises(AssertionError, list, chain(gen1(), gen2(True)))
  485.         self.assertEqual(hist, [0,1])
  486.  
  487.         hist = []
  488.         self.assertRaises(AssertionError, list, cycle(gen1()))
  489.         self.assertEqual(hist, [0,1])
  490.  
  491. libreftest = """ Doctest for examples in the library reference: libitertools.tex
  492.  
  493.  
  494. >>> amounts = [120.15, 764.05, 823.14]
  495. >>> for checknum, amount in izip(count(1200), amounts):
  496. ...     print 'Check %d is for $%.2f' % (checknum, amount)
  497. ...
  498. Check 1200 is for $120.15
  499. Check 1201 is for $764.05
  500. Check 1202 is for $823.14
  501.  
  502. >>> import operator
  503. >>> for cube in imap(operator.pow, xrange(1,4), repeat(3)):
  504. ...    print cube
  505. ...
  506. 1
  507. 8
  508. 27
  509.  
  510. >>> reportlines = ['EuroPython', 'Roster', '', 'alex', '', 'laura', '', 'martin', '', 'walter', '', 'samuele']
  511. >>> for name in islice(reportlines, 3, None, 2):
  512. ...    print name.title()
  513. ...
  514. Alex
  515. Laura
  516. Martin
  517. Walter
  518. Samuele
  519.  
  520. >>> def enumerate(iterable):
  521. ...     return izip(count(), iterable)
  522.  
  523. >>> def tabulate(function):
  524. ...     "Return function(0), function(1), ..."
  525. ...     return imap(function, count())
  526.  
  527. >>> def iteritems(mapping):
  528. ...     return izip(mapping.iterkeys(), mapping.itervalues())
  529.  
  530. >>> def nth(iterable, n):
  531. ...     "Returns the nth item"
  532. ...     return list(islice(iterable, n, n+1))
  533.  
  534. >>> def all(seq, pred=bool):
  535. ...     "Returns True if pred(x) is True for every element in the iterable"
  536. ...     return False not in imap(pred, seq)
  537.  
  538. >>> def any(seq, pred=bool):
  539. ...     "Returns True if pred(x) is True for at least one element in the iterable"
  540. ...     return True in imap(pred, seq)
  541.  
  542. >>> def no(seq, pred=bool):
  543. ...     "Returns True if pred(x) is False for every element in the iterable"
  544. ...     return True not in imap(pred, seq)
  545.  
  546. >>> def quantify(seq, pred=bool):
  547. ...     "Count how many times the predicate is True in the sequence"
  548. ...     return sum(imap(pred, seq))
  549.  
  550. >>> def padnone(seq):
  551. ...     "Returns the sequence elements and then returns None indefinitely"
  552. ...     return chain(seq, repeat(None))
  553.  
  554. >>> def ncycles(seq, n):
  555. ...     "Returns the sequence elements n times"
  556. ...     return chain(*repeat(seq, n))
  557.  
  558. >>> def dotproduct(vec1, vec2):
  559. ...     return sum(imap(operator.mul, vec1, vec2))
  560.  
  561. >>> def window(seq, n=2):
  562. ...     "Returns a sliding window (of width n) over data from the iterable"
  563. ...     "   s -> (s0,s1,...s[n-1]), (s1,s2,...,sn), ...                   "
  564. ...     it = iter(seq)
  565. ...     result = tuple(islice(it, n))
  566. ...     if len(result) == n:
  567. ...         yield result
  568. ...     for elem in it:
  569. ...         result = result[1:] + (elem,)
  570. ...         yield result
  571.  
  572. >>> def take(n, seq):
  573. ...     return list(islice(seq, n))
  574.  
  575. This is not part of the examples but it tests to make sure the definitions
  576. perform as purported.
  577.  
  578. >>> list(enumerate('abc'))
  579. [(0, 'a'), (1, 'b'), (2, 'c')]
  580.  
  581. >>> list(islice(tabulate(lambda x: 2*x), 4))
  582. [0, 2, 4, 6]
  583.  
  584. >>> nth('abcde', 3)
  585. ['d']
  586.  
  587. >>> all([2, 4, 6, 8], lambda x: x%2==0)
  588. True
  589.  
  590. >>> all([2, 3, 6, 8], lambda x: x%2==0)
  591. False
  592.  
  593. >>> any([2, 4, 6, 8], lambda x: x%2==0)
  594. True
  595.  
  596. >>> any([1, 3, 5, 9], lambda x: x%2==0,)
  597. False
  598.  
  599. >>> no([1, 3, 5, 9], lambda x: x%2==0)
  600. True
  601.  
  602. >>> no([1, 2, 5, 9], lambda x: x%2==0)
  603. False
  604.  
  605. >>> quantify(xrange(99), lambda x: x%2==0)
  606. 50
  607.  
  608. >>> list(window('abc'))
  609. [('a', 'b'), ('b', 'c')]
  610.  
  611. >>> list(window('abc',5))
  612. []
  613.  
  614. >>> list(islice(padnone('abc'), 0, 6))
  615. ['a', 'b', 'c', None, None, None]
  616.  
  617. >>> list(ncycles('abc', 3))
  618. ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
  619.  
  620. >>> dotproduct([1,2,3], [4,5,6])
  621. 32
  622.  
  623. >>> take(10, count())
  624. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  625.  
  626. """
  627.  
  628. __test__ = {'libreftest' : libreftest}
  629.  
  630. def test_main(verbose=None):
  631.     test_classes = (TestBasicOps, TestVariousIteratorArgs, TestGC,
  632.                     RegressionTests)
  633.     test_support.run_unittest(*test_classes)
  634.  
  635.     # verify reference counting
  636.     if verbose and hasattr(sys, "gettotalrefcount"):
  637.         import gc
  638.         counts = [None] * 5
  639.         for i in xrange(len(counts)):
  640.             test_support.run_unittest(*test_classes)
  641.             gc.collect()
  642.             counts[i] = sys.gettotalrefcount()
  643.         print counts
  644.  
  645.     # doctest the examples in the library reference
  646.     test_support.run_doctest(sys.modules[__name__], verbose)
  647.  
  648. if __name__ == "__main__":
  649.     test_main(verbose=True)
  650.